> ## Documentation Index
> Fetch the complete documentation index at: https://sequence-0fb8d9e6-api_docs.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Blockchain Interactions

> Documentation for Unreal SDK API for writing to the blockchain with the Sequence infrastructure stack for web3 gaming.

<Warning>
  The examples below apply to versions 2.x.x.
  If you’re using version 3, use the SequenceEmbeddedWalletBP (Blueprints) and SequenceEmbeddedWallet (C++) classes instead.
</Warning>

## Sign Message

Sign a given message as a hex string. For example, you can use this signature to validate content on your backend.

<Tabs>
  <Tab title="Blueprint">
    <Frame>
      <img src="https://mintcdn.com/sequence-0fb8d9e6-api_docs/uFPNPaUQoWqBdCiH/images/unreal/sign_message.png?fit=max&auto=format&n=uFPNPaUQoWqBdCiH&q=85&s=75e58fe0d91a3a3ea4e41a09f8c1731c" width="2400" height="1184" data-path="images/unreal/sign_message.png" />
    </Frame>
  </Tab>

  <Tab title="C++">
    ```cpp theme={null}
     const TFunction<void(FSeqSignMessageResponse_Response)> OnApiSuccess = [OnSuccess](const FSeqSignMessageResponse_Response& SignedMessage) { };
     const TFunction<void(FSequenceError)> OnApiFailure = [OnFailure](const FSequenceError& Err) { };

     USequenceWallet* Wallet = NewObject<USequenceWallet>();
     Wallet->SignMessage(Message, OnApiSuccess, OnApiFailure);
    ```
  </Tab>
</Tabs>

## Send Native Tokens

Send native token balances to other users, such as sending ETH on the Ethereum Mainnet.

<Tabs>
  <Tab title="Blueprint">
    <Frame>
      <img src="https://mintcdn.com/sequence-0fb8d9e6-api_docs/auazpVRK2iFuGS6h/images/unreal/native_tokens_transaction.png?fit=max&auto=format&n=auazpVRK2iFuGS6h&q=85&s=157842ed8b2cd114e8a00783f578f6bf" width="2400" height="1184" data-path="images/unreal/native_tokens_transaction.png" />
    </Frame>
  </Tab>

  <Tab title="C++">
    ```cpp theme={null}
     const TFunction<void(FSeqTransactionResponse_Data)> OnApiSuccess = [OnSuccess](const FSeqTransactionResponse_Data& Response) { };
     const TFunction<void(FSequenceError)> OnApiFailure = [OnFailure](const FSequenceError& Err) { };

     USequenceWallet* Wallet = NewObject<USequenceWallet>();
     Wallet->SendNativeToken(RecipientAddress, Amount, OnApiSuccess, OnApiFailure);
    ```
  </Tab>
</Tabs>

## Send ERC20 Tokens

Send your custom ERC20 tokens from Builder to users, or transfer existing tokens like USDC or WETH.

<Tabs>
  <Tab title="Blueprint">
    <Frame>
      <img src="https://mintcdn.com/sequence-0fb8d9e6-api_docs/auazpVRK2iFuGS6h/images/unreal/erc20_transaction.png?fit=max&auto=format&n=auazpVRK2iFuGS6h&q=85&s=d57f9ba95e72d3b223eb638b5457f9a4" width="2400" height="1184" data-path="images/unreal/erc20_transaction.png" />
    </Frame>
  </Tab>

  <Tab title="C++">
    ```cpp theme={null}
    UTransactions* Txn = NewObject<UTransactions>();

    // Create the ERC20 transaction
    FERC20Transaction T20;
    T20.to = "0x0E0f9d1c4BeF9f0B8a2D9D4c09529F260C7758A2";
    T20.tokenAddress = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
    T20.value = "1000";

    // Append the ERC20 transaction to the Txn object
    Txn.Push(TUnion<FRawTransaction, FERC20Transaction, FERC721Transaction, FERC1155Transaction, FDelayedTransaction>(T20));

    const TFunction<void(FSeqTransactionResponse_Data)> OnApiSuccess = [OnSuccess](const FSeqTransactionResponse_Data& Response) { };
    const TFunction<void(FSequenceError)> OnApiFailure = [OnFailure](const FSequenceError& Err) { };

    USequenceWallet* Wallet = NewObject<USequenceWallet>();
    Wallet->SendTransaction(Transactions->GetTransactions(), OnApiSuccess, OnApiFailure);
    ```
  </Tab>
</Tabs>

## Send NFTs (ERC721 Tokens)

Enable your users to send NFTs to others.

<Tabs>
  <Tab title="Blueprint">
    <Frame>
      <img src="https://mintcdn.com/sequence-0fb8d9e6-api_docs/auazpVRK2iFuGS6h/images/unreal/erc721_transaction.png?fit=max&auto=format&n=auazpVRK2iFuGS6h&q=85&s=7eba02dce4c215fdf3cfeaab63486336" width="1216" height="600" data-path="images/unreal/erc721_transaction.png" />
    </Frame>
  </Tab>

  <Tab title="C++">
    ```cpp theme={null}
     UTransactions* Txn = NewObject<UTransactions>();

     // Create the ERC721 transaction
     FERC721Transaction T721;
     T721.safe = true;
     T721.id = "54530968763798660137294927684252503703134533114052628080002308208148824588621";
     T721.to = "0x0E0f9d1c4BeF9f0B8a2D9D4c09529F260C7758A2";
     T721.tokenAddress = "0xa9a6A3626993D487d2Dbda3173cf58cA1a9D9e9f";

     // Append the ERC721 transaction to the Txn object
     Txn.Push(TUnion<FRawTransaction, FERC20Transaction, FERC721Transaction, FERC1155Transaction, FDelayedTransaction>(T721));

     const TFunction<void(FSeqTransactionResponse_Data)> OnApiSuccess = [OnSuccess](const FSeqTransactionResponse_Data& Response) { };
     const TFunction<void(FSequenceError)> OnApiFailure = [OnFailure](const FSequenceError& Err) { };

     USequenceWallet* Wallet = NewObject<USequenceWallet>();
     Wallet->SendTransaction(Transactions->GetTransactions(), OnApiSuccess, OnApiFailure);
    ```
  </Tab>
</Tabs>

## Send Collectibles (ERC1155 Tokens)

Enable your users to send Collectibles to others.

<Tabs>
  <Tab title="Blueprint">
    <Frame>
      <img src="https://mintcdn.com/sequence-0fb8d9e6-api_docs/CmKz04BVDGuy1x-Z/images/unreal/erc1155_transaction.png?fit=max&auto=format&n=CmKz04BVDGuy1x-Z&q=85&s=52fffe059992dc5a6457498cd33b9fd8" width="2400" height="1184" data-path="images/unreal/erc1155_transaction.png" />
    </Frame>
  </Tab>

  <Tab title="C++">
    ```cpp theme={null}
     UTransactions* Txn = NewObject<UTransactions>();

     // Create the ERC1155 transaction
     FERC1155Transaction T1155;
     T1155.to = "0x0E0f9d1c4BeF9f0B8a2D9D4c09529F260C7758A2";
     T1155.tokenAddress = "0x631998e91476DA5B870D741192fc5Cbc55F5a52E";

     FERC1155TxnValue Val;
     Val.amount = "1";
     Val.id = "66635";
     T1155.vals.Add(Val);

     // Append the ERC1155 transaction to the Txn object
     Txn.Push(TUnion<FRawTransaction, FERC20Transaction, FERC721Transaction, FERC1155Transaction, FDelayedTransaction>(T1155));

     const TFunction<void(FSeqTransactionResponse_Data)> OnApiSuccess = [OnSuccess](const FSeqTransactionResponse_Data& Response) { };
     const TFunction<void(FSequenceError)> OnApiFailure = [OnFailure](const FSequenceError& Err) { };

     USequenceWallet* Wallet = NewObject<USequenceWallet>();
     Wallet->SendTransaction(Transactions->GetTransactions(), OnApiSuccess, OnApiFailure);
    ```
  </Tab>
</Tabs>

## Send Raw Transactions

<Note>
  If you want call contracts with the Raw type you'll want include the header #include "ABI/ABI.h" in order to use the ABI to encode the data for a contract call.
</Note>

<Tabs>
  <Tab title="Blueprint">
    <Frame>
      <img src="https://mintcdn.com/sequence-0fb8d9e6-api_docs/uFPNPaUQoWqBdCiH/images/unreal/raw_transaction.png?fit=max&auto=format&n=uFPNPaUQoWqBdCiH&q=85&s=021208506d05ff52c43d0c059d2b93c6" width="2400" height="1184" data-path="images/unreal/raw_transaction.png" />
    </Frame>
  </Tab>

  <Tab title="C++">
    ```cpp theme={null}
    void UMyClass::BurnToken(TArray<TUnion<FRawTransaction, FERC20Transaction, FERC721Transaction, FERC1155Transaction, FDelayedTransaction>> Txn, FString ContractAddress, int32 TokenId, int32 Amount)
    {
        FString FunctionSignature = "burn(uint256,uint256)";
        TFixedABIData ABITokenId = ABI::Int32(TokenId);
        TFixedABIData ABIFixedAmount = ABI::Int32(Amount);
        TArray<ABIEncodeable*> Arr;
        Arr.Add(&ABITokenId);
        Arr.Add(&ABIFixedAmount);
        FUnsizedData EncodedData = ABI::Encode(FunctionSignature, Arr);
        FRawTransaction T;
        T.data = "0x" + EncodedData.ToHex();
        T.to = ContractAddress;
        T.value = "0"

        // Append the Raw Transaction
        Txn.Push(TUnion<FRawTransaction, FERC20Transaction, FERC721Transaction, FERC1155Transaction, FDelayedTransaction>(T));
    }
    ```
  </Tab>
</Tabs>

## Send Delayed Encode Transactions

When working with Blueprints, it is easier to call a contract via server-side encoding using a Delayed Encode transaction.

<Tabs>
  <Tab title="Blueprint">
    <Frame>
      <img src="https://mintcdn.com/sequence-0fb8d9e6-api_docs/CmKz04BVDGuy1x-Z/images/unreal/delayed_encode.png?fit=max&auto=format&n=CmKz04BVDGuy1x-Z&q=85&s=caf4889aa229c8dd551258ba59d30ccf" width="1645" height="700" data-path="images/unreal/delayed_encode.png" />
    </Frame>
  </Tab>

  <Tab title="C++">
    ```cpp theme={null}
    FDelayedTransaction DelayedEncodeTxn;
    DelayedEncodeTxn.to = ERC20Address;
    DelayedEncodeTxn.value = TEXT("0");
    UDelayedEncodingBP* data = NewObject<UDelayedEncodingBP>();
    data->SetAbi(TEXT("mint(address,uint256)"));
    UDelayedEncodingArrayArgsBP* args = NewObject<UDelayedEncodingArrayArgsBP>();
    args->AddStringArg(WalletAddress);
    args->AddStringArg("1");
    data->SetArgs(args);
    data->SetFunc(TEXT("mint"));
    DelayedEncodeTxn.data = data;
    Transactions.Add(TransactionUnion(DelayedEncodeTxn));
    ```
  </Tab>
</Tabs>

## Send Transactions with Fee Options

To send transactions with fee options, first retrieve the available fee options using the `GetFeeOptions` method.
Once the fee options are received, select a fee option and use the `SendTransactionWithFeeOption` method to send
the transaction with the selected fee.

<Tabs>
  <Tab title="Blueprint">
    <Frame>
      <img src="https://mintcdn.com/sequence-0fb8d9e6-api_docs/uFPNPaUQoWqBdCiH/images/unreal/transaction_with_fee.png?fit=max&auto=format&n=uFPNPaUQoWqBdCiH&q=85&s=61cf8697c2caff93061c38c9abbdbfda" width="2534" height="1294" data-path="images/unreal/transaction_with_fee.png" />
    </Frame>
  </Tab>

  <Tab title="C++">
    ```cpp theme={null}
    // Define the callback for handling the fee options response
    const TFunction<void(TArray<FFeeOption>)> OnFeeResponse = [Transactions, OnSuccess, OnFailure](const TArray<FFeeOption>& Response)
    {
        if (Response.Num() > 0)
    {
        const FFeeOption SelectedFeeOption = Response[0];
        UE_LOG(LogTemp, Display, TEXT("Using FeeOption: %s"), *UIndexerSupport::StructToString(SelectedFeeOption));

        const FFailureCallback OnTransactionFailure = [OnFailure](const FSequenceError& Error)
    {
        OnFailure("Transaction failure", Error);
    };

        const UAuthenticator* Auth = NewObject<UAuthenticator>();
        const TOptional<USequenceWallet*> WalletOptional = USequenceWallet::Get(Auth->GetStoredCredentials().GetCredentials());
        if (WalletOptional.IsSet() && WalletOptional.GetValue())
    {
        USequenceWallet* Wallet = WalletOptional.GetValue();
        Wallet->SendTransactionWithFeeOption(Transactions, SelectedFeeOption, [=](const FSeqTransactionResponse_Data& Transaction)
    {
        FString OutputString;
        const TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&OutputString);
        FJsonSerializer::Serialize(Transaction.Json.ToSharedRef(), Writer);
        OnSuccess(OutputString);
    }, OnTransactionFailure);
    }
    }
        else
    {
        OnFailure("Test failed no fee options in response", FSequenceError(EErrorType::EmptyResponse, "Empty fee option response"));
    }
    };

    // Define the callback for handling fee options retrieval failure
    const FFailureCallback OnFeeFailure = [OnFailure](const FSequenceError& Error)
    {
        OnFailure("Get Fee Option Response failure", Error);
    };

    // Retrieve fee options and send the transaction with the selected fee option
    const UAuthenticator* Auth = NewObject<UAuthenticator>();
        const TOptional<USequenceWallet*> WalletOptional = USequenceWallet::Get(Auth->GetStoredCredentials().GetCredentials());
        if (WalletOptional.IsSet() && WalletOptional.GetValue())
        {
            USequenceWallet* Wallet = WalletOptional.GetValue();
            Wallet->GetFeeOptions(Transactions, OnFeeResponse, OnFeeFailure);
        }
    ```
  </Tab>
</Tabs>